package pcloud.client.remoteservice;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.util.LinkedList;
import java.util.List;

import pcloud.client.util.FileResourceInfo;
import pcloud.client.util.GlobalConfig;
import pcloud.client.util.Logger;

import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.net.SocketException;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;

public class FTPService implements FileService
{
	private FTPClient ftpClient = new FTPClient();

	/**
	 * 连接到FTP服务器
	 * 
	 * @param hostname
	 *            主机名
	 * @param port
	 *            端口
	 * @param username
	 *            用户名
	 * @param password
	 *            密码
	 * @return 是否连接成功
	 * @throws IOException
	 */
	private boolean connect(String hostname, int port, String username,
			String password) throws IOException
	{
		ftpClient.connect(hostname, port);
		ftpClient.setControlEncoding("GBK");
		FTPClientConfig  conf = new FTPClientConfig(FTPClientConfig.SYST_NT);
		conf.setServerLanguageCode("zh");
		if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
			if (ftpClient.login(username, password)) {
				ftpClient.enterLocalPassiveMode();
//				ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

				return true;
			}
		}
		disconnect();
		return false;
	}

	/**
	 * 从FTP服务器上下载文件,支持断点续传，上传百分比汇报
	 * 
	 * @param remote
	 *            远程文件路径
	 * @param local
	 *            本地文件路径
	 * @return 上传的状态
	 * @throws IOException
	 */
	private DownloadStatus download(String remote, String local)
			throws IOException
	{
		// 设置被动模式
		ftpClient.enterLocalPassiveMode();
		// 设置以二进制方式传输
		ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
		DownloadStatus result;

		// 检查远程文件是否存在
		FTPFile[] files = ftpClient.listFiles(new String(
				remote.getBytes("GBK"), "iso-8859-1"));
		if (files.length != 1) {
			System.out.println("远程文件不存在");
			return DownloadStatus.Remote_File_Noexist;
		}

		long lRemoteSize = files[0].getSize();
		File f = new File(local);
		// 本地存在文件，进行断点下载
		if (f.exists()) {
			long localSize = f.length();
			// 判断本地文件大小是否大于远程文件大小
			if (localSize >= lRemoteSize) {
				System.out.println("本地文件大于远程文件，下载中止");
				return DownloadStatus.Local_Bigger_Remote;
			}

			// 进行断点续传，并记录状态
			FileOutputStream out = new FileOutputStream(f, true);
			ftpClient.setRestartOffset(localSize);
			InputStream in = ftpClient.retrieveFileStream(new String(remote
					.getBytes("GBK"), "iso-8859-1"));
			byte[] bytes = new byte[1024];
			long step = lRemoteSize / 100;
			long process = localSize / step;
			int c;
			while ((c = in.read(bytes)) != -1) {
				out.write(bytes, 0, c);
				localSize += c;
				long nowProcess = localSize / step;
				if (nowProcess > process) {
					process = nowProcess;
					if (process % 10 == 0)
						System.out.println("下载进度：" + process);
					// TODO 更新文件下载进度,值存放在process变量中
				}
			}
			in.close();
			out.close();
			boolean isDo = ftpClient.completePendingCommand();
			if (isDo) {
				result = DownloadStatus.Download_From_Break_Success;
			} else {
				result = DownloadStatus.Download_From_Break_Failed;
			}
		} else {
			OutputStream out = new FileOutputStream(f);
			InputStream in = ftpClient.retrieveFileStream(new String(remote
					.getBytes("GBK"), "iso-8859-1"));
			byte[] bytes = new byte[1024];
			long step = lRemoteSize / 100;
			long process = 0;
			long localSize = 0L;
			int c;
			while ((c = in.read(bytes)) != -1) {
				out.write(bytes, 0, c);
				localSize += c;
				long nowProcess = localSize / step;
				if (nowProcess > process) {
					process = nowProcess;
					if (process % 10 == 0)
						System.out.println("下载进度：" + process);
					// TODO 更新文件下载进度,值存放在process变量中
				}
			}
			in.close();
			out.close();
			boolean upNewStatus = ftpClient.completePendingCommand();
			if (upNewStatus) {
				result = DownloadStatus.Download_New_Success;
			} else {
				result = DownloadStatus.Download_New_Failed;
			}
		}
		return result;
	}

	/**
	 * 上传文件到FTP服务器，支持断点续传
	 * 
	 * @param local
	 *            本地文件名称，绝对路径
	 * @param remote
	 *            远程文件路径，使用/home/directory1/subdirectory/file.ext
	 *            按照Linux上的路径指定方式，支持多级目录嵌套，支持递归创建不存在的目录结构
	 * @return 上传结果
	 * @throws IOException
	 */
	private UploadStatus upload(String local, String remote) throws IOException
	{
		// 设置PassiveMode传输
		ftpClient.enterLocalPassiveMode();
		// 设置以二进制流的方式传输
//		ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
		ftpClient.setControlEncoding("GBK");
		UploadStatus result;
		// 对远程目录的处理
		String remoteFileName = remote;
		if (remote.contains("/")) {
			remoteFileName = remote.substring(remote.lastIndexOf("/") + 1);
			// 创建服务器远程目录结构，创建失败直接返回
			if (createDirectory(remote) == UploadStatus.Create_Directory_Fail) {
				return UploadStatus.Create_Directory_Fail;
			}
		}
		// ftpClient.feat();

		// System.out.println( ftpClient.getReply());
		// System.out.println( ftpClient.acct(null));
		// System.out.println(ftpClient.getReplyCode());
		// System.out.println(ftpClient.getReplyString());

		// 检查远程是否存在文件
		FTPFile[] files = ftpClient.listFiles(new String(remoteFileName
				.getBytes("GBK"), "iso-8859-1"));
		if (files.length == 1) {
			long remoteSize = files[0].getSize();
			File f = new File(local);
			long localSize = f.length();
			if (remoteSize == localSize) { // 文件存在且完整
				return UploadStatus.File_Exits;
			} else if (remoteSize > localSize) {
				return UploadStatus.Remote_Bigger_Local;
			}

			// 尝试移动文件内读取指针,实现断点续传
			result = uploadFile(remoteFileName, f, remoteSize);

			// 如果断点续传没有成功，则删除服务器上文件，重新上传
			if (result == UploadStatus.Upload_From_Break_Failed) {
				if (!ftpClient.deleteFile(remoteFileName)) {
					return UploadStatus.Delete_Remote_Faild;
				}
				result = uploadFile(remoteFileName, f);
			}
		} else {
			result = uploadFile(remoteFileName, new File(local));
		}
		return result;
	}

	/**
	 * 断开与远程服务器的连接
	 * 
	 * @throws IOException
	 */
	private void disconnect() throws IOException
	{
		if (ftpClient.isConnected()) {
			ftpClient.disconnect();
		}
	}

	/**
	 * 递归创建远程服务器目录
	 * 
	 * @param remote
	 *            远程服务器文件绝对路径
	 * @param ftpClient
	 *            FTPClient对象
	 * @return 目录创建是否成功
	 * @throws IOException
	 */
	private UploadStatus createDirectory(String remote) throws IOException
	{
		UploadStatus status = UploadStatus.Create_Directory_Success;
		String directory = remote.substring(0, remote.lastIndexOf("/") + 1);
		if (!directory.equalsIgnoreCase("/")
				&& !ftpClient.changeWorkingDirectory(new String(directory
						.getBytes("GBK"), "iso-8859-1"))) {
			// 如果远程目录不存在，则递归创建远程服务器目录
			int start = 0;
			int end = 0;
			if (directory.startsWith("/")) {
				start = 1;
			} else {
				start = 0;
			}
			end = directory.indexOf("/", start);
			while (true) {
				String subDirectory = new String(remote.substring(start, end)
						.getBytes("GBK"), "iso-8859-1");
				if (!ftpClient.changeWorkingDirectory(subDirectory)) {
					if (ftpClient.makeDirectory(subDirectory)) {
						ftpClient.changeWorkingDirectory(subDirectory);
					} else {
						System.out.println("创建目录失败");
						return UploadStatus.Create_Directory_Fail;
					}
				}

				start = end + 1;
				end = directory.indexOf("/", start);

				// 检查所有目录是否创建完毕
				if (end <= start) {
					break;
				}
			}
		}
		return status;
	}

	private UploadStatus uploadFile(String remoteFile, File localFile)
			throws IOException
	{
		return uploadFile(remoteFile, localFile, 0);
	}

	/**
	 * 上传文件到服务器,新上传和断点续传
	 * 
	 * @param remoteFile
	 *            远程文件名，在上传之前已经将服务器工作目录做了改变
	 * @param localFile
	 *            本地文件File句柄，绝对路径
	 * @param processStep
	 *            需要显示的处理进度步进值
	 * @param ftpClient
	 *            FTPClient引用
	 * @return
	 * @throws IOException
	 */
	private UploadStatus uploadFile(String remoteFile, File localFile,
			long remoteSize) throws IOException
	{
//		ftpClient.sendCommand("OPTS UTF8", "ON");
		String remote = new String(remoteFile.getBytes("UTF-8"), "iso-8859-1");
//		String remote = remoteFile;
		// 如果不需要断点续传, 那么新建一个文件
		if (remoteSize <= 0) {
			FileInputStream localFileInputStream = new FileInputStream(localFile);
			String destinationFileName = localFile.getName();
//			String tempFileName = " temp_ " + destinationFileName;
			// 上传本地文件到服务器上(文件名以'temp_'开头，当上传完毕后，名字改为正式名)
			boolean flag = ftpClient.storeFile(destinationFileName, localFileInputStream);
//			if (flag) {
//				log.info(" upload success !!! ");
//				// 上传完毕后，名字改为正式名(该方法在远程有效，本地不用此方法，而用renameTo方法)
//				ftpClient.rename(tempFileName, destinationFileName);
//			}
			// 关闭文件流
			localFileInputStream.close();
			if (flag) {
				return UploadStatus.Upload_New_File_Success;
			} else {
				String message = ftpClient.getReplyString();
				throw new RuntimeException(message);
			}
		}

		// 如果文件存在则覆盖或续传
		// 显示进度的上传
		UploadStatus status;
		long step = localFile.length() / 100;
		long process = 0;
		long localreadbytes = 0L;
		RandomAccessFile raf = new RandomAccessFile(localFile, "r");
		// 断点续传
		if (remoteSize > 0) {
			ftpClient.setRestartOffset(remoteSize);
			process = remoteSize / step;
			raf.seek(remoteSize);
			localreadbytes = remoteSize;
		}
		byte[] bytes = new byte[1024];
		int c;
		OutputStream out = ftpClient.appendFileStream(remote);
		while ((c = raf.read(bytes)) != -1) {
			out.write(bytes, 0, c);
			localreadbytes += c;
			if (localreadbytes / step != process) {
				process = localreadbytes / step;
				System.out.println("上传进度:" + process);
				// TODO 汇报上传状态

			}
		}
		out.flush();
		raf.close();
		out.close();
		boolean result = ftpClient.completePendingCommand();
		if (remoteSize > 0) {
			status = result ? UploadStatus.Upload_From_Break_Success
					: UploadStatus.Upload_From_Break_Failed;
		} else {
			status = result ? UploadStatus.Upload_New_File_Success
					: UploadStatus.Upload_New_File_Failed;
		}
		return status;
	}

	/**
	 * 获取指定目录下的文件名称列表
	 * 
	 * @author HQQW510_64
	 * @param currentDir
	 *            需要获取其子目录的当前目录名称
	 * @return 返回子目录字符串数组
	 */
	private String[] GetFileNames(String currentDir)
	{
		String[] dirs = null;
		try {
			if (currentDir == null)
				dirs = ftpClient.listNames();
			else
				dirs = ftpClient.listNames(currentDir);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return dirs;
	}

	/**
	 * 获取指定目录下的文件与目录信息集合
	 * 
	 * @param currentDir
	 *            指定的当前目录
	 * @return 返回的文件集合
	 */
	private FTPFile[] GetDirAndFilesInfo(String currentDir)
	{
		FTPFile[] files = null;

		try {
			if (currentDir == null)
				files = ftpClient.listFiles();
			else
				files = ftpClient.listFiles(currentDir);
		} catch (IOException ex) {
			// TODO Auto-generated catch block
			ex.printStackTrace();
		}
		return files;
	}

	private String serviceUrl;

	private FTPService()
	{
	};

	public static FileService createInstance(String serviceUrl,
			String username, String password)
	{
		FTPService service = new FTPService();
		service.serviceUrl = service.validateRootUrl(serviceUrl);
		service.ftpClient = new FTPClient();
		try {
			service.connect(serviceUrl, 21, username, password);
			logger.info("RemoteService connected!");
		} catch (SocketException e) {
			e.printStackTrace();
			return null;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
		return service;
	}

	@Override
	public void release()
	{
		try {
			this.disconnect();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private String validateRootUrl(String url)
	{
		if (url.charAt(url.length() - 1) == '/') {
			return url.substring(0, url.length() - 1);
		}
		return url;
	}

	@Override
	public boolean createFolder(String path) throws IOException
	{
		if (!ftpClient.isConnected()) {
			return false;
		}
		createDirectory(path);
		return true;
	}

	private String getFullPath(String pathFromRoot)
	{
		String url = serviceUrl + pathFromRoot;
		return url;
	}

	@Override
	public boolean deleteFile(String path) throws IOException
	{
		String url = getFullPath(path);
		if (ftpClient.isConnected()) {
			ftpClient.deleteFile(url);
			return true;
		}
		return false;
	}

	@Override
	public boolean uploadFile(FileResourceInfo fileInfo) throws IOException
	{
		File localFile = new File(fileInfo.getFullPath());
		String remotePath = fileInfo.getRelativePath();
		logger.info("before upload file, remotePath:["+remotePath+", localFile:["+localFile+"]");
		uploadFile(remotePath, localFile);
//		upload(fileInfo.getFullPath(), remotePath);
		return true;
	}

	@Override
	public boolean downloadFile(FileResourceInfo fileInfo) throws IOException
	{
		if (!fileInfo.isRemote()) {
			return false;
		}
		String remotePath = fileInfo.getFullPath();

		String remoteRootPath = fileInfo.getRootPath();
		String localRootPath = GlobalConfig.getInstance().getLocalSyncFolder(
				remoteRootPath);
		download(remotePath, localRootPath + fileInfo.getRelativePath());

		return true;
	}

	// public InputStream downloadFile(String path) throws IOException
	// {
	// return download(path, path);
	// }

	@Override
	public List<FileResourceInfo> list(String path) throws IOException
	{
		FTPFile[] ftpFiles = GetDirAndFilesInfo(path);
		List<FileResourceInfo> fileInfoList = new LinkedList<FileResourceInfo>();
		for (FTPFile ftpFile : ftpFiles) {
			FileResourceInfo fileInfo = createFileResourceInfo(ftpFile);
			fileInfoList.add(fileInfo);
		}

		return fileInfoList;
	}

	@Override
	public FileResourceInfo getResource(String path) throws IOException
	{
		// List<DavResource> davResourceList = ftpClient.get;
		// DavResource davResource = davResourceList.get(0);
		//
		// FileResourceInfo fileInfo = createFileResourceInfo(davResource);
		return null;
	}

	private FileResourceInfo createFileResourceInfo(FTPFile ftpFile)
	{
		FileResourceInfo fileInfo = new FileResourceInfo();
		fileInfo.setLength(ftpFile.getSize());
		// fileInfo.setCreationDate(ftpFile.getTimestamp().getTime().getTime());
		fileInfo.setLastModified(ftpFile.getTimestamp().getTime().getTime());
		fileInfo.setFilename(ftpFile.getName());
		fileInfo.setFullPath(ftpFile.getName());
		return fileInfo;
	}

	public boolean isConnected()
	{
		return ftpClient.isConnected();
	}

	@Override
	public boolean uploadFile(String path, InputStream dataStream)
			throws IOException
	{
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean deleteFolder(String path) throws IOException
	{
		// TODO Auto-generated method stub
		return false;
	}

}
